home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 2 / Meeting Pearls Vol. II (1995)(GTI - Schatztruhe)[!].iso / Pearls / arc / XFH / src / xfhsrc / xfh.c < prev    next >
C/C++ Source or Header  |  1992-12-14  |  30KB  |  1,499 lines
  1. /* prima di ogni SetGadgetAttrs() verificare che il gadget sia attaccato */
  2. /* creare dinamicamente anche i primarygadgets oltre ai secondarygadgets */
  3.  
  4. /* mostrare requester se non c'e` xpkmaster 2.2 */
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <exec/types.h>
  10. #include <exec/memory.h>
  11. #include <exec/devices.h>
  12. #include <intuition/intuitionbase.h>
  13. #include <intuition/gadgetclass.h>
  14. #include <graphics/gfxbase.h>
  15. #include <graphics/gfxmacros.h>
  16. #include <workbench/startup.h>
  17. #include <libraries/dosextens.h>
  18. #include <libraries/gadtools.h>
  19. #include <libraries/xpk.h>
  20. #include <proto/exec.h>
  21. #include <proto/dos.h>
  22. #include <proto/graphics.h>
  23. #include <proto/commodities.h>
  24. #include <proto/icon.h>
  25. #include <proto/intuition.h>
  26. #include <proto/gadtools.h>
  27. #include "xfhsem.h"
  28.  
  29. CxObj __stdargs *HotKey( STRPTR description, struct MsgPort *port, long id );
  30.  
  31.  
  32. UBYTE versionstring20[] = "\0$VER: xfh 1.01 (14.12.92)";
  33.  
  34.  
  35. #define WINDOWWIDTH 466L
  36. #define PACKERDESCCHARS 39
  37. #define DEVLISTCHARS 50
  38.  
  39. struct MyXPINFO
  40. {
  41.     struct Node nd;
  42.     XPINFO xpinfo;
  43. };
  44.  
  45. struct MyXFHNode
  46. {
  47.     struct Node nd;
  48.     struct XFHNode xfh;
  49. };
  50.  
  51. #define POP_KEY_ID (86L)        /* pop up identifier */
  52.  
  53.  
  54. UBYTE iconname[] = "PROGDIR:XFH";
  55. UBYTE lowmemtxt[] = "LOWMEM";
  56. UBYTE compresstxt[] = "COMPRESS";
  57. UBYTE hotkeybuff[257];
  58. UBYTE windowtitle[130];
  59. WORD dontpop;
  60.  
  61.  
  62. enum { DEVLISTID = 1, LOWMEMID, AUTOPACKID, SELECTPACKERID,
  63.         PACKERLISTID, EFFICID, OKID, CANCELID };
  64.  
  65.  
  66. struct GfxBase *GfxBase;
  67. struct IntuitionBase *IntuitionBase;
  68. struct Library *GadToolsBase;
  69. struct Library *CxBase;
  70. struct Library *IconBase;
  71. struct Library *XpkBase;
  72.  
  73. struct WBStartup *WBenchMsg;
  74.  
  75.  
  76. struct Screen *screen;
  77. struct Window *window;
  78. struct Menu *menu;
  79. APTR vi;
  80. struct TextFont *topazfont;
  81. struct Gadget *glist1,*glist2,*devlistgad,*lowmemgad,*autopackgad,*selectpackergad,
  82.         *packernamegad,*packerlistgad,*desc1gad,*desc2gad,*desc3gad,*efficgad,
  83.         *modegad,*cfgad,*psgad,*usgad;
  84.  
  85. UBYTE modestr[10],cfstr[5],psstr[10],usstr[10];
  86.  
  87. WORD displayedgads;    /* 0 no gadgets, 1 primary set, 2 secondary set */
  88.  
  89. struct List xfhlist;
  90. struct List packerlist;
  91.  
  92. struct MyXFHNode *selecteddevice;
  93. LONG numselecteddevice = ~0L;
  94. struct MyXPINFO *selectedpacker;
  95. LONG numselectedpacker = ~0L;
  96.  
  97.  
  98. CxObj *broker;
  99.  
  100. struct NewBroker mynb =
  101. {
  102.     NB_VERSION,
  103.     "XFH",
  104.     "XFH Controller:",
  105.     "Control XFH Features",
  106.     NBU_NOTIFY | NBU_UNIQUE,
  107.     COF_SHOW_HIDE,
  108. };
  109.  
  110. struct MsgPort *cxport;        /* commodities messages here      */
  111. ULONG cxsigflag = 0;        /* signal for above               */
  112. LONG winleft = -1;
  113. LONG wintop = -1;
  114.  
  115.  
  116. enum {MEN_SAVE=1,MEN_HIDE,MEN_QUIT};
  117.  
  118. struct NewMenu menudef[] =
  119. {
  120. { NM_TITLE,    "Project",    0,    0,                    0,    (APTR)0 },
  121. {  NM_ITEM,    "Save",        "S",    0,                    0,    (APTR)MEN_SAVE },
  122. {  NM_ITEM,    NM_BARLABEL,    0,    0,                    0,    (APTR)0 },
  123. {  NM_ITEM,    "Hide",        "H",    0,                    0,    (APTR)MEN_HIDE },
  124. {  NM_ITEM,    "Quit",        "Q",    0,                    0,    (APTR)MEN_QUIT },
  125. { NM_END,     0,            0,    0,                    0,    (APTR)0 }
  126. };
  127.  
  128.  
  129. struct TextAttr tanormal =
  130. {
  131.     "topaz.font",
  132.     8,
  133.     FS_NORMAL,
  134.     FPF_ROMFONT,
  135. };
  136.  
  137.  
  138. struct Window *openwindow(VOID);
  139. LONG createmaingadgets(VOID);
  140. LONG createsecondarygadgets(VOID);
  141. VOID closewindow(VOID);
  142. VOID builddevslist(VOID);
  143. VOID buildpackerslist(VOID);
  144. VOID ClearWindow(struct Window *win);
  145. VOID PrintInfoSelectedDevice(VOID);
  146. VOID PrintInfoSelectedPacker(VOID);
  147. VOID PrintInfoSelectedMode(VOID);
  148. struct XFHSemaphore *GetSemaphore(VOID);
  149. VOID InitXFHSemaphore(VOID);
  150. VOID saveconfig(VOID);
  151. VOID updatesemaphore(struct MyXFHNode *nd);
  152. VOID notifyhandler(struct XFHNode *node);
  153. VOID AddAlpha(struct List *list,struct Node *node);
  154. VOID FreeList(struct List *list);
  155. VOID cleanup(LONG code);
  156.  
  157. BOOL setupCX(VOID);
  158. VOID shutdownCX(VOID);
  159.  
  160.  
  161.  
  162.  
  163. void __stdargs __main(char *stub)
  164. {
  165. ULONG recsignal,windowsignal;
  166. struct Process *process;
  167. WORD done = 0;
  168. ULONG cl = 0;
  169. UWORD code;
  170. struct IntuiMessage *msg;
  171. struct Gadget *gadg;
  172. CxMsg *cxmsg;
  173. extern struct WBStartup *WBenchMsg;
  174.  
  175.  
  176. NewList(&xfhlist);
  177. NewList(&packerlist);
  178.  
  179. if (!(process = (struct Process *)FindTask(NULL))->pr_CLI)    /* from Workbench */
  180. {
  181.     WaitPort(&process->pr_MsgPort);
  182.     WBenchMsg = (struct WBStartup *)GetMsg(&process->pr_MsgPort);
  183. }
  184.  
  185.  
  186. if (!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",37)) ||
  187.         !(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37)) ||
  188.         !(GadToolsBase = OpenLibrary("gadtools.library",37)) ||
  189.         !(CxBase = OpenLibrary("commodities.library",37)) ||
  190.         !(IconBase = OpenLibrary("icon.library",37)) ||
  191.         !(XpkBase = OpenLibrary(XPKNAME,2)))
  192.     cleanup(RETURN_FAIL);
  193.  
  194.  
  195. strcpy(hotkeybuff,"control alt x");
  196. strcpy(windowtitle,"XFH: Hot Key = <");
  197.  
  198. if (WBenchMsg)        /* from Workbench */
  199. {
  200.     struct WBArg *wbarg;
  201.     struct DiskObject *dskobj;
  202.     BPTR curdir;
  203.  
  204.  
  205.     wbarg = WBenchMsg->sm_ArgList;
  206.  
  207.     curdir = CurrentDir(wbarg->wa_Lock);
  208.  
  209.     if (dskobj = GetDiskObject((UBYTE *)wbarg->wa_Name))
  210.     {
  211.         UBYTE *tt;
  212.  
  213.  
  214.         if (tt = FindToolType(dskobj->do_ToolTypes,"CX_PRIORITY"))
  215.         {
  216.             LONG val;
  217.  
  218.  
  219.             StrToLong(tt,&val);
  220.             mynb.nb_Pri = val;
  221.         }
  222.         if (tt = FindToolType(dskobj->do_ToolTypes,"CX_POPKEY"))
  223.             strncpy(hotkeybuff,tt,256);
  224.         if (tt = FindToolType(dskobj->do_ToolTypes,"CX_POPUP"))
  225.             if (!stricmp(tt,"NO")) dontpop = 1;
  226.  
  227.         FreeDiskObject(dskobj);
  228.     }
  229.  
  230.     CurrentDir(curdir);
  231. }
  232. else                /* from CLI */
  233. {
  234.     struct RDArgs *rdargs = 0;
  235.     LONG argarray[3];
  236.  
  237.  
  238.     argarray[0] = argarray[1] = argarray[2] = 0;
  239.  
  240.     if (rdargs = ReadArgs("CX_PRIORITY/N/K,CX_POPKEY/K,CX_POPUP/K",
  241.             argarray,NULL))
  242.     {
  243.         if (argarray[0]) mynb.nb_Pri = *((LONG *)argarray[0]);
  244.         if (argarray[1]) strncpy(hotkeybuff,(UBYTE *)argarray[1],256);
  245.         if (argarray[2] && !stricmp((UBYTE *)argarray[2],"NO")) dontpop = 1;
  246.  
  247.         FreeArgs(rdargs);
  248.     }
  249.     else
  250.     {
  251.         PrintFault(IoErr(),NULL);
  252.         cleanup(RETURN_ERROR);
  253.     }
  254. }
  255.  
  256. strncat(windowtitle,hotkeybuff,100);
  257. strcat(windowtitle,">");
  258.  
  259. if (!setupCX()) cleanup(RETURN_OK);    /* return_ok because it failed 'cos XFH was already running */
  260.  
  261. InitXFHSemaphore();
  262.  
  263. if (!dontpop)
  264. {
  265.     if (!openwindow()) closewindow();
  266. }
  267.  
  268.  
  269. do
  270. {
  271.     windowsignal = (window ? 1L << window->UserPort->mp_SigBit : 0);
  272.  
  273.     recsignal = Wait(windowsignal | cxsigflag | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_F);
  274.  
  275.     if (recsignal & cxsigflag)
  276.     {
  277.         while (cxport && !done && (cxmsg = (CxMsg *)GetMsg(cxport)))
  278.         {
  279.             switch(CxMsgType(cxmsg))
  280.             {
  281.             case CXM_IEVENT:
  282.                 switch(CxMsgID(cxmsg))
  283.                 {
  284.                 case POP_KEY_ID:
  285.                     if (!openwindow()) closewindow();
  286.                     break;
  287.                 }
  288.                 break;
  289.             case CXM_COMMAND:
  290.                 switch(CxMsgID(cxmsg))
  291.                 {
  292.                 case CXCMD_DISABLE:
  293.                     ActivateCxObj(broker,0L);
  294.                     break;
  295.                 case CXCMD_ENABLE:
  296.                     ActivateCxObj(broker,1L);
  297.                     break;
  298.                 case CXCMD_APPEAR:
  299.                 case CXCMD_UNIQUE:
  300.                     if (!openwindow()) closewindow();
  301.                     break;
  302.                 case CXCMD_DISAPPEAR:
  303.                     closewindow();
  304.                     break;
  305.                 case CXCMD_KILL:
  306.                     done = 1;
  307.                     break;
  308.                 }
  309.                 break;
  310.             }
  311.  
  312.             ReplyMsg((struct Message *)cxmsg);
  313.         }
  314.     }
  315.  
  316.     if (recsignal & SIGBREAKF_CTRL_C)
  317.         done = 1;
  318.  
  319.     if ((recsignal & SIGBREAKF_CTRL_F) && !done)
  320.         if (!openwindow()) closewindow();
  321.  
  322.     if (recsignal & windowsignal)
  323.     {
  324.         while (window && !done && (msg = GT_GetIMsg(window->UserPort)))
  325.         {
  326.             cl = msg->Class;
  327.             code = msg->Code;
  328.             gadg = (struct Gadget *)msg->IAddress;
  329.             GT_ReplyIMsg(msg);
  330.  
  331.             switch (cl)
  332.             {
  333.             case IDCMP_REFRESHWINDOW:
  334.                 GT_BeginRefresh(window);
  335.                 GT_EndRefresh(window,TRUE);
  336.                 break;
  337.             case IDCMP_CLOSEWINDOW:
  338.                 closewindow();
  339.                 break;
  340.             case IDCMP_GADGETUP:
  341.                 switch (gadg->GadgetID)
  342.                 {
  343.                 case DEVLISTID:
  344.                     {
  345.                         struct MyXFHNode *nd,*nextnd;
  346.                         UWORD j = 0;
  347.  
  348.  
  349.                         numselecteddevice = code;
  350.  
  351.                         nd = (struct MyXFHNode *)xfhlist.lh_Head;
  352.                         while (j < code && (nextnd = (struct MyXFHNode *)nd->nd.ln_Succ))
  353.                         {
  354.                             nd = nextnd;
  355.                             j++;
  356.                         }
  357.                         if (nd->nd.ln_Succ) selecteddevice = nd;
  358.                         else        /* /// this really shouldn't happen */
  359.                         {
  360.                             selecteddevice = NULL;
  361.                             numselecteddevice = ~0L;
  362.  
  363.                             GT_SetGadgetAttrs(devlistgad,window,NULL,
  364.                                     GTLV_Selected,~0L,
  365.                                     TAG_DONE);
  366.                         }
  367.  
  368.                         PrintInfoSelectedDevice();
  369.                     }
  370.                     break;
  371.                 case LOWMEMID:
  372.                     if (selecteddevice)
  373.                         selecteddevice->xfh.xfh_LowMemory ^= 1;
  374.                     break;
  375.                 case AUTOPACKID:
  376.                     if (selecteddevice)
  377.                     {
  378.                         selecteddevice->xfh.xfh_AutoPack ^= 1;
  379.  
  380.                         GT_SetGadgetAttrs(selectpackergad,window,NULL,
  381.                                 GA_Disabled,(LONG)!selecteddevice->xfh.xfh_AutoPack,
  382.                                 TAG_DONE);
  383.                     }
  384.                     break;
  385.                 case SELECTPACKERID:
  386.                     if (selecteddevice && displayedgads == 1)
  387.                     {
  388.                         struct MyXPINFO *nd,*nextnd;
  389.                         UWORD j = 0;
  390.  
  391.  
  392.                     /* find the packer associated with selected device */
  393.                         nd = (struct MyXPINFO *)packerlist.lh_Head;
  394.                         j = 0;
  395.                         selectedpacker = NULL;
  396.                         numselectedpacker = ~0L;
  397.                         while ((nextnd = (struct MyXPINFO *)nd->nd.ln_Succ))
  398.                         {
  399.                             if (!strcmp((UBYTE *)&selecteddevice->xfh.xfh_PackerID,nd->nd.ln_Name))
  400.                             {
  401.                                 selectedpacker = nd;
  402.                                 numselectedpacker = j;
  403.                                 if ((selectedpacker->xpinfo.DefMode = selecteddevice->xfh.xfh_PackMode) > 100)
  404.                                 {
  405.                                     XPINFO xpinfo;
  406.  
  407.  
  408.                                     if (!XpkQueryTags(
  409.                                             XPK_PackerQuery,&xpinfo,
  410.                                             XPK_PackMethod,(UBYTE *)&selecteddevice->xfh.xfh_PackerID,
  411.                                             TAG_DONE))
  412.                                         selectedpacker->xpinfo.DefMode = xpinfo.DefMode;
  413.                                 }
  414.  
  415.                                 break;
  416.                             }
  417.                             nd = nextnd;
  418.                             j++;
  419.                         }
  420.  
  421.  
  422.                         if (createsecondarygadgets())
  423.                         {
  424.                             RemoveGList(window,glist1,-1);
  425.  
  426.                             ClearWindow(window);
  427.  
  428.                             AddGList(window,glist2,-1,-1,NULL);
  429.  
  430.                             RefreshGList(glist2,window,NULL,-1);
  431.  
  432.                             GT_RefreshWindow(window,NULL);
  433.  
  434.                             displayedgads = 2;
  435.  
  436.                             PrintInfoSelectedPacker();
  437.                         }
  438.                     }
  439.                     break;
  440.                 case PACKERLISTID:
  441.                     {
  442.                         struct MyXPINFO *nd,*nextnd;
  443.                         UWORD j = 0;
  444.  
  445.  
  446.                         numselectedpacker = code;
  447.  
  448.                         nd = (struct MyXPINFO *)packerlist.lh_Head;
  449.                         while (j < code && (nextnd = (struct MyXPINFO *)nd->nd.ln_Succ))
  450.                         {
  451.                             nd = nextnd;
  452.                             j++;
  453.                         }
  454.                         if (nd->nd.ln_Succ) selectedpacker = nd;
  455.                         else        /* /// this really shouldn't happen */
  456.                         {
  457.                             selectedpacker = NULL;
  458.                             numselectedpacker = ~0L;
  459.  
  460.                             GT_SetGadgetAttrs(packerlistgad,window,NULL,
  461.                                     GTLV_Selected,~0L,
  462.                                     TAG_DONE);
  463.                         }
  464.  
  465.                         PrintInfoSelectedPacker();
  466.                     }
  467.                     break;
  468.                 case OKID:
  469.                     if (selecteddevice)
  470.                     {
  471.                         if (selectedpacker)
  472.                         {
  473.                             strcpy((UBYTE *)&selecteddevice->xfh.xfh_PackerID,selectedpacker->nd.ln_Name);
  474.                             if (selectedpacker->xpinfo.Flags & XPKIF_MODES)
  475.                                 selecteddevice->xfh.xfh_PackMode = selectedpacker->xpinfo.DefMode;
  476.                             else selecteddevice->xfh.xfh_PackMode = (UBYTE)~0;
  477.                         }
  478.                         else selecteddevice->xfh.xfh_PackerID = NULL;
  479.                     }
  480.                 case CANCELID:
  481.                     if (displayedgads == 2)
  482.                     {
  483.                         RemoveGList(window,glist2,-1);
  484.  
  485.                         ClearWindow(window);
  486.  
  487.                         AddGList(window,glist1,-1,-1,NULL);
  488.  
  489.                         RefreshGList(glist1,window,NULL,-1);
  490.  
  491.                         GT_RefreshWindow(window,NULL);
  492.  
  493.                         if (glist2)    FreeGadgets(glist2);
  494.                         glist2 = NULL;
  495.  
  496.                         displayedgads = 1;
  497.  
  498.                         PrintInfoSelectedDevice();
  499.                     }
  500.                     break;
  501.                 }
  502.                 break;
  503.             case IDCMP_MOUSEMOVE:
  504.                 switch (gadg->GadgetID)
  505.                 {
  506.                 case EFFICID:
  507.                     if (selectedpacker) selectedpacker->xpinfo.DefMode = code;
  508.                     PrintInfoSelectedMode();
  509.                     break;
  510.                 }
  511.                 break;
  512.             case IDCMP_MENUPICK:
  513.                 while (code != MENUNULL && !done)
  514.                 {
  515.                     struct MenuItem *item;
  516.  
  517.                     item = ItemAddress(menu,code);
  518.  
  519.                     switch((ULONG)MENU_USERDATA(item))
  520.                     {
  521.                     case MEN_HIDE:
  522.                         closewindow();
  523.                         break;
  524.                     case MEN_QUIT:
  525.                         done = 1;
  526.                         break;
  527.                     case MEN_SAVE:
  528.                         saveconfig();
  529.                         break;
  530.                     }
  531.  
  532.                 /* ensure that the menu is still there (in case the window closed) */
  533.                     if (menu) code = item->NextSelect;
  534.                     else code = MENUNULL;
  535.                 }
  536.                 break;
  537.             }
  538.         }
  539.     }
  540. } while (!done);
  541.  
  542. cleanup(RETURN_OK);
  543. }
  544.  
  545.  
  546.  
  547. struct Window *openwindow(VOID)
  548. {
  549. static WORD zoom[4] = { 0,0,200,-1 };
  550.  
  551.  
  552. if (window)
  553. {
  554.     ActivateWindow(window);
  555.     WindowToFront(window);
  556.     if (window->Flags & WFLG_ZOOMED) ZipWindow(window);
  557.  
  558.     return(window);
  559. }
  560.  
  561. if (!(topazfont = OpenFont(&tanormal))) return(0);
  562.  
  563. if (!(screen = LockPubScreen(NULL)))
  564.     return(0);
  565.  
  566. if (IntuitionBase->LibNode.lib_Version >= 39) zoom[0] = zoom[1] = -1;
  567. else zoom[1] = screen->BarHeight + 1;
  568. zoom[3] = screen->WBorTop + screen->Font->ta_YSize + 1;
  569.  
  570. if (winleft == -1) winleft = 0;
  571. if (wintop == -1) wintop = screen->BarHeight + 1;
  572.  
  573. if (!(window = OpenWindowTags(NULL,
  574.         WA_Left,winleft,
  575.         WA_Top,wintop,
  576.         WA_Width,WINDOWWIDTH,
  577.         WA_InnerHeight,140L,
  578.         WA_Zoom,zoom,
  579.         WA_DragBar,1L,
  580.         WA_DepthGadget,1L,
  581.         WA_CloseGadget,1L,
  582.         WA_IDCMP,(ULONG)BUTTONIDCMP | LISTVIEWIDCMP | CHECKBOXIDCMP | SLIDERIDCMP
  583.                 | IDCMP_CLOSEWINDOW | IDCMP_MENUPICK | IDCMP_REFRESHWINDOW,
  584.         WA_Activate,1L,
  585.         WA_SimpleRefresh,1L,
  586.         WA_Title,windowtitle,
  587.         WA_PubScreen,screen,
  588.         WA_NewLookMenus,1L,
  589.         TAG_DONE)) || !(vi = GetVisualInfo(window->WScreen,NULL)))
  590.     return(0);
  591.  
  592. SetFont(window->RPort,topazfont);
  593.  
  594. if (!(menu = CreateMenusA(menudef,TAG_DONE)) || !LayoutMenus(menu,vi,
  595.         GTMN_NewLookMenus,1L,
  596.         TAG_DONE))
  597.     return(0);
  598.  
  599. SetMenuStrip(window,menu);
  600.  
  601. if (!createmaingadgets()) return(0);
  602.  
  603. AddGList(window,glist1,-1,-1,NULL);
  604.  
  605. RefreshGList(glist1,window,NULL,-1);
  606.  
  607. GT_RefreshWindow(window,NULL);
  608.  
  609. displayedgads = 1;
  610.  
  611. builddevslist();
  612. buildpackerslist();
  613.  
  614. GT_SetGadgetAttrs(devlistgad,window,NULL,
  615.         GTLV_Labels,&xfhlist,
  616.         TAG_DONE);
  617.  
  618. return(window);
  619. }
  620.  
  621.  
  622.  
  623. LONG createmaingadgets(VOID)
  624. {
  625. struct NewGadget newg;
  626. struct Gadget *gadg;
  627.  
  628.  
  629. if (!(gadg = CreateContext(&glist1)))
  630.     return(0);
  631.  
  632. newg.ng_Width = WINDOWWIDTH-24;
  633. newg.ng_Height = 70;
  634. newg.ng_GadgetText = "XFH Device";
  635. newg.ng_TextAttr = &tanormal;
  636. newg.ng_VisualInfo = vi;
  637. newg.ng_GadgetID = DEVLISTID;
  638. newg.ng_Flags = 0;
  639. newg.ng_LeftEdge = 12;
  640. newg.ng_TopEdge = window->BorderTop + 16;
  641.  
  642. if (!(devlistgad = gadg = CreateGadget(LISTVIEW_KIND,gadg,&newg,
  643.         GTLV_ShowSelected,0L,
  644.         GTLV_ScrollWidth,18L,
  645.         LAYOUTA_Spacing,1L,
  646.         TAG_DONE)))
  647.     return(0);
  648.  
  649. newg.ng_GadgetText = "Low Memory";
  650. newg.ng_GadgetID = LOWMEMID;
  651. newg.ng_Flags = PLACETEXT_RIGHT;
  652. newg.ng_TopEdge = window->BorderTop + 92;
  653.  
  654. if (!(lowmemgad = gadg = CreateGadget(CHECKBOX_KIND,gadg,&newg,
  655.         GA_Disabled,1L,
  656.         TAG_DONE)))
  657.     return(0);
  658.  
  659. newg.ng_GadgetText = "Compression";
  660. newg.ng_GadgetID = AUTOPACKID;
  661. newg.ng_LeftEdge = 242;
  662.  
  663. if (!(autopackgad = gadg = CreateGadget(CHECKBOX_KIND,gadg,&newg,
  664.         GA_Disabled,1L,
  665.         TAG_DONE)))
  666.     return(0);
  667.  
  668. newg.ng_Width = 212;
  669. newg.ng_Flags = 0;
  670. newg.ng_GadgetText = "Select Compressor...";
  671. newg.ng_GadgetID = SELECTPACKERID;
  672. newg.ng_Height = 14;
  673. newg.ng_TopEdge = window->BorderTop + 105;
  674.  
  675. if (!(selectpackergad = gadg = CreateGadget(BUTTON_KIND,gadg,&newg,
  676.         GA_Disabled,1L,
  677.         TAG_DONE)))
  678.     return(0);
  679.  
  680. newg.ng_GadgetText = "Compressor:";
  681. newg.ng_GadgetID = 0;
  682. newg.ng_TopEdge = window->BorderTop + 121;
  683.  
  684. if (!(packernamegad = gadg = CreateGadget(TEXT_KIND,gadg,&newg,
  685.         GTTX_Border,1L,
  686.         TAG_DONE)))
  687.     return(0);
  688.  
  689. return(1);
  690. }
  691.  
  692.  
  693.  
  694. LONG createsecondarygadgets(VOID)
  695. {
  696. struct NewGadget newg;
  697. struct Gadget *gadg;
  698.  
  699.  
  700. if (!(gadg = CreateContext(&glist2)))
  701.     goto fail;
  702.  
  703. newg.ng_Width = 110;
  704. newg.ng_Height = 100;
  705. newg.ng_GadgetText = "Compressor";
  706. newg.ng_TextAttr = &tanormal;
  707. newg.ng_VisualInfo = vi;
  708. newg.ng_GadgetID = PACKERLISTID;
  709. newg.ng_Flags = 0;
  710. newg.ng_LeftEdge = 12;
  711. newg.ng_TopEdge = window->BorderTop + 16;
  712.  
  713. if (!(packerlistgad = gadg = CreateGadget(LISTVIEW_KIND,gadg,&newg,
  714.         GTLV_Labels,&packerlist,
  715.         GTLV_Selected,numselectedpacker,
  716.         GTLV_ShowSelected,0L,
  717.         GTLV_ScrollWidth,18L,
  718.         LAYOUTA_Spacing,1L,
  719.         TAG_DONE)))
  720.     goto fail;
  721.  
  722. newg.ng_Width = 87;
  723. newg.ng_Height = 14;
  724. newg.ng_GadgetText = "OK";
  725. newg.ng_GadgetID = OKID;
  726. newg.ng_TopEdge = window->Height - 19;
  727.  
  728. if (!(gadg = CreateGadget(BUTTON_KIND,gadg,&newg,
  729.         TAG_DONE)))
  730.     goto fail;
  731.  
  732. newg.ng_GadgetText = "Cancel";
  733. newg.ng_GadgetID = CANCELID;
  734. newg.ng_LeftEdge = WINDOWWIDTH - 99;
  735.  
  736. if (!(gadg = CreateGadget(BUTTON_KIND,gadg,&newg,
  737.         TAG_DONE)))
  738.     goto fail;
  739.  
  740. newg.ng_Width = PACKERDESCCHARS*8+8;
  741. newg.ng_Height = 40;
  742. newg.ng_GadgetText = "Description";
  743. newg.ng_GadgetID = 0;
  744. newg.ng_Flags = PLACETEXT_ABOVE;
  745. newg.ng_LeftEdge = WINDOWWIDTH - PACKERDESCCHARS*8-8-12;
  746. newg.ng_TopEdge = window->BorderTop + 16;
  747.  
  748. if (!(gadg = CreateGadget(TEXT_KIND,gadg,&newg,
  749.         GTTX_Border,1L,
  750.         TAG_DONE)))
  751.     goto fail;
  752.  
  753. newg.ng_Width = PACKERDESCCHARS*8;
  754. newg.ng_Height = 14;
  755. newg.ng_GadgetText = NULL;
  756. newg.ng_Flags = 0;
  757. newg.ng_LeftEdge = WINDOWWIDTH - PACKERDESCCHARS*8-4-12;
  758. newg.ng_TopEdge = window->BorderTop + 18;
  759.  
  760. if (!(desc1gad = gadg = CreateGadget(TEXT_KIND,gadg,&newg,
  761.         TAG_DONE)))
  762.     goto fail;
  763.  
  764. newg.ng_TopEdge = window->BorderTop + 29;
  765.  
  766. if (!(desc2gad = gadg = CreateGadget(TEXT_KIND,gadg,&newg,
  767.         TAG_DONE)))
  768.     goto fail;
  769.  
  770. newg.ng_TopEdge = window->BorderTop + 40;
  771.  
  772. if (!(desc3gad = gadg = CreateGadget(TEXT_KIND,gadg,&newg,
  773.         TAG_DONE)))
  774.     goto fail;
  775.  
  776. newg.ng_Width = 140;
  777. newg.ng_Height = 11;
  778. newg.ng_GadgetText = "Efficiency:     ";
  779. newg.ng_GadgetID = EFFICID;
  780. newg.ng_LeftEdge = WINDOWWIDTH - 140-12;
  781. newg.ng_TopEdge = window->BorderTop + 62;
  782.  
  783. if (!(efficgad = gadg = CreateGadget(SLIDER_KIND,gadg,&newg,
  784.         GTSL_Min,0L,
  785.         GTSL_Max,100L,
  786.         GTSL_LevelFormat,"%3ld%%",
  787.         GTSL_MaxLevelLen,4L,
  788.         GTSL_Level,(LONG)(selectedpacker ? selectedpacker->xpinfo.DefMode : 50),
  789.         GA_Disabled,(LONG)!(selectedpacker && selectedpacker->xpinfo.Flags & XPKIF_MODES),
  790.         TAG_DONE)))
  791.     goto fail;
  792.  
  793. newg.ng_Width = 80;
  794. newg.ng_Height = 14;
  795. newg.ng_GadgetText = "Mode:";
  796. newg.ng_TopEdge = window->BorderTop + 75;
  797. modestr[0] = 0;
  798.  
  799. if (!(modegad = gadg = CreateGadget(TEXT_KIND,gadg,&newg,
  800.         TAG_DONE)))
  801.     goto fail;
  802.  
  803. newg.ng_Width = 40;
  804. newg.ng_GadgetText = "Compression:";
  805. newg.ng_TopEdge = window->BorderTop + 85;
  806. cfstr[0] = 0;
  807.  
  808. if (!(cfgad = gadg = CreateGadget(TEXT_KIND,gadg,&newg,
  809.         TAG_DONE)))
  810.     goto fail;
  811.  
  812. newg.ng_Width = 80;
  813. newg.ng_GadgetText = "Compression Speed:";
  814. newg.ng_TopEdge = window->BorderTop + 95;
  815. psstr[0] = 0;
  816.  
  817. if (!(psgad = gadg = CreateGadget(TEXT_KIND,gadg,&newg,
  818.         TAG_DONE)))
  819.     goto fail;
  820.  
  821. newg.ng_GadgetText = "Decompression Speed:";
  822. newg.ng_TopEdge = window->BorderTop + 105;
  823. usstr[0] = 0;
  824.  
  825. if (!(usgad = gadg = CreateGadget(TEXT_KIND,gadg,&newg,
  826.         TAG_DONE)))
  827.     goto fail;
  828.  
  829. return(1);
  830.  
  831.  
  832. fail:
  833.  
  834. if (glist2)    FreeGadgets(glist2);
  835. glist2 = NULL;
  836. return(0);
  837. }
  838.  
  839.  
  840.  
  841. VOID closewindow(VOID)
  842. {
  843. if (menu)
  844. {
  845.     ClearMenuStrip(window);
  846.     FreeMenus(menu);
  847.     menu = NULL;
  848. }
  849. if (window)
  850. {
  851.     winleft = window->LeftEdge;
  852.     wintop = window->TopEdge;
  853.     CloseWindow(window);
  854.     window = NULL;
  855. }
  856. if (glist1)
  857. {
  858.     FreeGadgets(glist1);
  859.     glist1 = NULL;
  860. }
  861. if (glist2)
  862. {
  863.     FreeGadgets(glist2);
  864.     glist2 = NULL;
  865. }
  866. if (vi)
  867. {
  868.     FreeVisualInfo(vi);
  869.     vi = NULL;
  870. }
  871. if (screen)
  872. {
  873.     UnlockPubScreen(NULL,screen);
  874.     screen = NULL;
  875. }
  876. if (topazfont)
  877. {
  878.     CloseFont(topazfont);
  879.     topazfont = NULL;
  880. }
  881.  
  882.  
  883. /* signal XFH handlers about changes */
  884. {
  885.     struct MyXFHNode *nd,*nextnd;
  886.  
  887.     nd = (struct MyXFHNode *)xfhlist.lh_Head;
  888.     while (nextnd = (struct MyXFHNode *)nd->nd.ln_Succ)
  889.     {
  890.         updatesemaphore(nd);
  891.  
  892.         nd = nextnd;
  893.     }
  894. }
  895. FreeList(&xfhlist);
  896.  
  897. selecteddevice = NULL;
  898. numselecteddevice = ~0;
  899.  
  900. FreeList(&packerlist);
  901. }
  902.  
  903.  
  904.  
  905. VOID builddevslist(VOID)
  906. {
  907. struct XFHSemaphore *sem;
  908.  
  909.  
  910. if (sem = GetSemaphore())
  911. {
  912.     struct MyXFHNode *node;
  913.     struct XFHNode *se,*nse;
  914.  
  915.  
  916.     se = (struct XFHNode *)sem->xfh_DeviceList.lh_Head;
  917.  
  918.     while (nse = (struct XFHNode *)se->xfh_Node.ln_Succ)
  919.     {
  920.         if (node = AllocVec(sizeof(struct MyXFHNode) + strlen(se->xfh_Node.ln_Name)
  921.                 + DEVLISTCHARS + 2,MEMF_CLEAR))
  922.         {
  923.             CopyMem(se,&node->xfh,sizeof(struct XFHNode));
  924.             node->nd.ln_Name = (UBYTE *)(node + 1);
  925.             node->xfh.xfh_Node.ln_Name = node->nd.ln_Name + DEVLISTCHARS + 1;
  926.             strncpy(node->nd.ln_Name,se->xfh_Node.ln_Name,10);
  927.             strcpy(node->xfh.xfh_Node.ln_Name,se->xfh_Node.ln_Name);
  928.             AddAlpha(&xfhlist,node);
  929.         }
  930.  
  931.         se = nse;
  932.     }
  933.  
  934.     ReleaseSemaphore(sem);
  935. }
  936.  
  937. {
  938.     struct MyXFHNode *se,*nse;
  939.  
  940.  
  941.     se = (struct MyXFHNode *)xfhlist.lh_Head;
  942.     while (nse = (struct MyXFHNode *)se->nd.ln_Succ)
  943.     {
  944.         if (se->xfh.xfh_RootLock)
  945.         {
  946.             UBYTE *buf = se->nd.ln_Name;
  947.  
  948.  
  949.             strcat(buf,"           ");
  950.             buf[10] = '(';
  951.             NameFromLock(se->xfh.xfh_RootLock,&buf[11],DEVLISTCHARS-12);
  952.             strcat(buf,")");
  953.         }
  954.  
  955.         se = nse;
  956.     }
  957. }
  958. }
  959.  
  960.  
  961.  
  962. VOID buildpackerslist(VOID)
  963. {
  964. XPLIST *list;
  965.  
  966.  
  967. if (list = AllocMem(sizeof(XPLIST),0))
  968. {
  969.     if (!XpkQueryTags(
  970.             XPK_PackersQuery,list,
  971.             TAG_DONE))
  972.     {
  973.         ULONG i;
  974.  
  975.  
  976.         for (i = 0;i < list->NumPackers;i++)
  977.         {
  978.             XPINFO xpinfo;
  979.  
  980.  
  981.             if (!XpkQueryTags(
  982.                     XPK_PackerQuery,&xpinfo,
  983.                     XPK_PackMethod,list->Packer[i],
  984.                     TAG_DONE) && !(xpinfo.Flags & XPKIF_NEEDPASSWD))
  985.             {
  986.                 struct MyXPINFO *node;
  987.  
  988.  
  989.                 if (node = AllocVec(sizeof(struct MyXPINFO) + 4 + 1,MEMF_CLEAR))
  990.                 {
  991.                     node->nd.ln_Name = (UBYTE *)(node + 1);
  992.                     strncpy(node->nd.ln_Name,(UBYTE *)list->Packer[i],4);
  993.                     CopyMem(&xpinfo,&node->xpinfo,sizeof(XPINFO));
  994.                     AddAlpha(&packerlist,node);
  995.                 }
  996.             }
  997.         }
  998.     }
  999.  
  1000.     FreeMem(list,sizeof(XPLIST));
  1001. }
  1002. }
  1003.  
  1004.  
  1005.  
  1006. VOID ClearWindow(struct Window *win)
  1007. {
  1008. ULONG minx,maxx,miny,maxy;
  1009.  
  1010.  
  1011. minx = win->BorderLeft;
  1012. miny = win->BorderTop;
  1013. maxx = win->Width - win->BorderRight - 1;
  1014. maxy = win->Height - win->BorderBottom - 1;
  1015.  
  1016. if (minx <= maxx && miny <= maxy)
  1017.     EraseRect(win->RPort,minx,miny,maxx,maxy);
  1018. }
  1019.  
  1020.  
  1021.  
  1022. VOID PrintInfoSelectedDevice(VOID)
  1023. {
  1024. static UBYTE packername[10];
  1025.  
  1026.  
  1027. packername[0] = 0;
  1028.  
  1029. if (selecteddevice)
  1030. {
  1031.     GT_SetGadgetAttrs(lowmemgad,window,NULL,
  1032.             GTCB_Checked,(LONG)selecteddevice->xfh.xfh_LowMemory,
  1033.             GA_Disabled,0L,
  1034.             TAG_DONE);
  1035.  
  1036.     GT_SetGadgetAttrs(autopackgad,window,NULL,
  1037.             GTCB_Checked,(LONG)selecteddevice->xfh.xfh_AutoPack,
  1038.             GA_Disabled,0L,
  1039.             TAG_DONE);
  1040.  
  1041.     if (selecteddevice->xfh.xfh_PackerID)
  1042.         sprintf(packername,(selecteddevice->xfh.xfh_PackMode <= 100 ? "%s.%ld" : "%s"),(UBYTE *)&selecteddevice->xfh.xfh_PackerID,(LONG)selecteddevice->xfh.xfh_PackMode);
  1043. }
  1044. else
  1045. {
  1046.     GT_SetGadgetAttrs(lowmemgad,window,NULL,
  1047.             GA_Disabled,1L,
  1048.             TAG_DONE);
  1049.  
  1050.     GT_SetGadgetAttrs(autopackgad,window,NULL,
  1051.             GA_Disabled,1L,
  1052.             TAG_DONE);
  1053. }
  1054.  
  1055. GT_SetGadgetAttrs(selectpackergad,window,NULL,
  1056.         GA_Disabled,(LONG)!(selecteddevice && selecteddevice->xfh.xfh_AutoPack),
  1057.         TAG_DONE);
  1058.  
  1059. GT_SetGadgetAttrs(packernamegad,window,NULL,
  1060.         GTTX_Text,packername,
  1061.         TAG_DONE);
  1062. }
  1063.  
  1064.  
  1065.  
  1066. VOID PrintInfoSelectedPacker(VOID)
  1067. {
  1068. static UBYTE descr2[PACKERDESCCHARS+1],descr3[PACKERDESCCHARS+1];
  1069.  
  1070.  
  1071. GT_SetGadgetAttrs(efficgad,window,NULL,
  1072.         GTSL_Level,(LONG)(selectedpacker ? selectedpacker->xpinfo.DefMode : 50),
  1073.         GA_Disabled,(LONG)!(selectedpacker && selectedpacker->xpinfo.Flags & XPKIF_MODES),
  1074.         TAG_DONE);
  1075.  
  1076. GT_SetGadgetAttrs(desc1gad,window,NULL,
  1077.         GTTX_Text,(selectedpacker ? selectedpacker->xpinfo.LongName : NULL),
  1078.         TAG_DONE);
  1079.  
  1080. if (selectedpacker)
  1081. {
  1082.     descr2[PACKERDESCCHARS] = 0;
  1083.     strncpy(descr2,(UBYTE *)selectedpacker->xpinfo.Description,PACKERDESCCHARS);
  1084.  
  1085.     if (strlen((UBYTE *)selectedpacker->xpinfo.Description) > PACKERDESCCHARS)
  1086.     {
  1087.         WORD l = PACKERDESCCHARS;
  1088.  
  1089.  
  1090.         while(selectedpacker->xpinfo.Description[l] != ' ') l--;
  1091.  
  1092.         descr2[l] = 0;
  1093.         strncpy(descr3,(UBYTE *)&selectedpacker->xpinfo.Description[l+1],PACKERDESCCHARS);
  1094.         descr3[PACKERDESCCHARS] = 0;
  1095.     }
  1096.     else descr3[0] = 0;
  1097. }
  1098. else descr2[0] = descr3[0] = 0;
  1099.  
  1100. GT_SetGadgetAttrs(desc2gad,window,NULL,
  1101.         GTTX_Text,descr2,
  1102.         TAG_DONE);
  1103.  
  1104. GT_SetGadgetAttrs(desc3gad,window,NULL,
  1105.         GTTX_Text,descr3,
  1106.         TAG_DONE);
  1107.  
  1108. PrintInfoSelectedMode();
  1109. }
  1110.  
  1111.  
  1112.  
  1113. VOID PrintInfoSelectedMode(VOID)
  1114. {
  1115. XMINFO xminfo;
  1116. UBYTE newmode[10],newcf[5],newps[20],newus[20];
  1117.  
  1118.  
  1119. if (selectedpacker && !XpkQueryTags(
  1120.         XPK_ModeQuery,&xminfo,
  1121.         XPK_PackMethod,selectedpacker->nd.ln_Name,
  1122.         XPK_PackMode,(LONG)selectedpacker->xpinfo.DefMode,
  1123.         TAG_DONE))
  1124. {
  1125.     strcpy(newmode,xminfo.Description);
  1126.     sprintf(newcf,"%ld%%",(LONG)xminfo.Ratio/10);
  1127.     sprintf(newps,"%ld K/s",xminfo.PackSpeed);
  1128.     sprintf(newus,"%ld K/s",xminfo.UnpackSpeed);
  1129. }
  1130. else newmode[0] = newcf[0] = newps[0] = newus[0] = 0;
  1131.  
  1132. if (strcmp(modestr,newmode))
  1133. {
  1134.     strcpy(modestr,newmode);
  1135.     GT_SetGadgetAttrs(modegad,window,NULL,
  1136.             GTTX_Text,modestr,
  1137.             TAG_DONE);
  1138. }
  1139.  
  1140. if (strcmp(cfstr,newcf))
  1141. {
  1142.     strcpy(cfstr,newcf);
  1143.     GT_SetGadgetAttrs(cfgad,window,NULL,
  1144.             GTTX_Text,cfstr,
  1145.             TAG_DONE);
  1146. }
  1147.  
  1148. if (strcmp(psstr,newps))
  1149. {
  1150.     strncpy(psstr,newps,9);
  1151.     GT_SetGadgetAttrs(psgad,window,NULL,
  1152.             GTTX_Text,psstr,
  1153.             TAG_DONE);
  1154. }
  1155.  
  1156. if (strcmp(usstr,newus))
  1157. {
  1158.     strncpy(usstr,newus,9);
  1159.     GT_SetGadgetAttrs(usgad,window,NULL,
  1160.             GTTX_Text,usstr,
  1161.             TAG_DONE);
  1162. }
  1163. }
  1164.  
  1165.  
  1166.  
  1167. /* Lock the semaphore and return a pointer to it, or NULL if it isn't there. */
  1168. /* If it can't find it, will try to create a new one; so this function will */
  1169. /* fail only due to severe low memory conditions */
  1170. /* When done with the list, the semaphore must be freed with ReleaseSemaphore() */
  1171. struct XFHSemaphore *GetSemaphore(VOID)
  1172. {
  1173. struct XFHSemaphore *sem;
  1174. static UBYTE xfhsemaphorename[] = XFHSEMAPHORENAME;
  1175.  
  1176.  
  1177. Forbid();
  1178.  
  1179. if (!(sem = (struct XFHSemaphore *)FindSemaphore(xfhsemaphorename)) &&
  1180.         (sem = AllocMem(sizeof(struct XFHSemaphore) + sizeof(xfhsemaphorename) + 1,MEMF_CLEAR | MEMF_PUBLIC)))
  1181. {
  1182.     sem->xfh_Length = sizeof(struct XFHSemaphore);
  1183.     sem->xfh_Semaphore.ss_Link.ln_Name = ((UBYTE *)(sem + 1));
  1184.     strcpy(sem->xfh_Semaphore.ss_Link.ln_Name,xfhsemaphorename);
  1185.     NewList(&sem->xfh_DeviceList);
  1186.     AddSemaphore(sem);
  1187. }
  1188.  
  1189. Permit();
  1190.  
  1191. /* out of Forbid() because the semaphore is guaranteed not to be removed */
  1192. if (sem) ObtainSemaphore(sem);
  1193.  
  1194. return(sem);
  1195. }
  1196.  
  1197.  
  1198.  
  1199. VOID InitXFHSemaphore(VOID)
  1200. {
  1201. struct DiskObject *dskobj;
  1202.  
  1203.  
  1204. if (dskobj = GetDiskObject(iconname))
  1205. {
  1206.     struct XFHSemaphore *sem;
  1207.  
  1208.  
  1209.     if (sem = GetSemaphore())
  1210.     {
  1211.         UBYTE **ttp;
  1212.  
  1213.  
  1214.         ttp = dskobj->do_ToolTypes;
  1215.         while (*ttp)
  1216.         {
  1217.             UBYTE *tt;
  1218.  
  1219.  
  1220.             tt = *ttp;
  1221.             if (tt[0] == '«')
  1222.             {
  1223.                 UBYTE *st1,*st2,*st3,*st4,*st5;
  1224.  
  1225.  
  1226.                 tt++;
  1227.                 st5 = 0;
  1228.                 if (st1 = strchr(tt,','))
  1229.                 {
  1230.                     *(st1++) = 0;
  1231.                     if (st2 = strchr(st1,','))
  1232.                     {
  1233.                         *(st2++) = 0;
  1234.                         if (st3 = strchr(st2,','))
  1235.                         {
  1236.                             *(st3++) = 0;
  1237.                             if (st4 = strchr(st3,'.'))
  1238.                             {
  1239.                                 *(st4++) = 0;
  1240.                                 st5 = strchr(st4,'»');
  1241.                             }
  1242.                     /* handle packerIDs with no explicit mode */
  1243.                             else if (st4 = strchr(st3,'»'))
  1244.                             {
  1245.                                 *st4 = 0;
  1246.                                 st5 = st4;
  1247.                             }
  1248.                         }
  1249.                     }
  1250.                 }
  1251.  
  1252.                 if (st5)
  1253.                 {
  1254.                     struct XFHNode *node;
  1255.  
  1256.  
  1257.                     if (!(node = (struct XFHNode *)FindName(&sem->xfh_DeviceList,tt))
  1258.                             && (node = AllocMem(sizeof(struct XFHNode) + strlen(tt) + 1,MEMF_CLEAR | MEMF_PUBLIC)))
  1259.                     {
  1260.                         node->xfh_Length = sizeof(struct XFHNode);
  1261.                         node->xfh_Node.ln_Name = (UBYTE *)(node + 1);
  1262.                         strcpy(node->xfh_Node.ln_Name,tt);
  1263.                         AddTail(&sem->xfh_DeviceList,node);
  1264.                     }
  1265.  
  1266.                     if (node)
  1267.                     {
  1268.                         node->xfh_LowMemory = !stricmp(st1,lowmemtxt);
  1269.                         node->xfh_AutoPack = !stricmp(st2,compresstxt);
  1270.                         if (strlen(st3) == 4)
  1271.                         {
  1272.                             LONG val;
  1273.  
  1274.  
  1275.                             strcpy((UBYTE *)&node->xfh_PackerID,st3);
  1276.                             if (st4 != st5)    /* check if there's an explicit mode */
  1277.                             {
  1278.                                 StrToLong(st4,&val);
  1279.                                 node->xfh_PackMode = val;
  1280.                             }
  1281.                             else node->xfh_PackMode = 0xff;
  1282.                         }
  1283.                         else node->xfh_PackerID = NULL;
  1284.  
  1285.                         notifyhandler(node);
  1286.                     }
  1287.                 }
  1288.             }
  1289.  
  1290.             ttp++;
  1291.         }
  1292.  
  1293.         ReleaseSemaphore(sem);
  1294.     }
  1295.  
  1296.     FreeDiskObject(dskobj);
  1297. }
  1298. }
  1299.  
  1300.  
  1301.  
  1302. VOID saveconfig(VOID)
  1303. {
  1304. struct DiskObject *dskobj;
  1305.  
  1306.  
  1307. if (dskobj = GetDiskObject(iconname))
  1308. {
  1309.     UBYTE **ttp;
  1310.     UBYTE *newttp[128];    /* /// reasonable limitation */
  1311.     WORD ttcnt = 0;
  1312.     struct MyXFHNode *nd,*nextnd;
  1313.     struct Remember *RememberKey = NULL;
  1314.  
  1315.  
  1316.     nd = (struct MyXFHNode *)xfhlist.lh_Head;
  1317.     while (nextnd = (struct MyXFHNode *)nd->nd.ln_Succ)
  1318.     {
  1319.         UBYTE *buf;
  1320.  
  1321.  
  1322.         if (buf = AllocRemember(&RememberKey,100,0))
  1323.         {
  1324.             sprintf(buf,((nd->xfh.xfh_PackerID && nd->xfh.xfh_PackMode <= 100)
  1325.                     ? "«%s,%s,%s,%s.%ld»" : "«%s,%s,%s,%s»"),
  1326.                     nd->xfh.xfh_Node.ln_Name,
  1327.                     nd->xfh.xfh_LowMemory ? lowmemtxt : "",
  1328.                     nd->xfh.xfh_AutoPack ? compresstxt : "",
  1329.                     (UBYTE *)&nd->xfh.xfh_PackerID,
  1330.                     (LONG)nd->xfh.xfh_PackMode);
  1331.  
  1332.             newttp[ttcnt++] = buf;
  1333.         }
  1334.  
  1335.         nd = nextnd;
  1336.     }
  1337.  
  1338.     /* copy remaining tooltypes */
  1339.     ttp = dskobj->do_ToolTypes;
  1340.     while (*ttp)
  1341.     {
  1342.         if (**ttp != (UBYTE)'«')
  1343.              newttp[ttcnt++] = *ttp;
  1344.  
  1345.         ttp++;
  1346.     }
  1347.     newttp[ttcnt] = NULL;
  1348.  
  1349.     ttp = dskobj->do_ToolTypes;
  1350.     dskobj->do_ToolTypes = newttp;
  1351.  
  1352.     PutDiskObject(iconname,dskobj);
  1353.  
  1354.     FreeRemember(&RememberKey,TRUE);
  1355.  
  1356.     dskobj->do_ToolTypes = ttp;
  1357.  
  1358.     FreeDiskObject(dskobj);
  1359. }
  1360. }
  1361.  
  1362.  
  1363.  
  1364. /* this function updates the semaphore list contents and signals the xfh */
  1365. /* task if mounted */
  1366. VOID updatesemaphore(struct MyXFHNode *nd)
  1367. {
  1368. struct XFHSemaphore *sem;
  1369.  
  1370.  
  1371. if (sem = GetSemaphore())
  1372. {
  1373.     struct XFHNode *ond;
  1374.  
  1375.  
  1376.     if (ond = (struct XFHNode *)FindName(&sem->xfh_DeviceList,nd->xfh.xfh_Node.ln_Name))
  1377.     {
  1378.         ond->xfh_AutoPack = nd->xfh.xfh_AutoPack;
  1379.         ond->xfh_PackerID = nd->xfh.xfh_PackerID;
  1380.         ond->xfh_PackMode = nd->xfh.xfh_PackMode;
  1381.         ond->xfh_LowMemory = nd->xfh.xfh_LowMemory;
  1382.  
  1383.         notifyhandler(ond);
  1384.     }
  1385.  
  1386.     ReleaseSemaphore(sem);
  1387. }
  1388. }
  1389.  
  1390.  
  1391.  
  1392.  
  1393. VOID notifyhandler(struct XFHNode *node)
  1394. {
  1395. if (node->xfh_Handler) Signal(node->xfh_Handler->mp_SigTask,SIGBREAKF_CTRL_F);
  1396. }
  1397.  
  1398.  
  1399.  
  1400. VOID AddAlpha(struct List *list,struct Node *node)
  1401. {
  1402. struct Node *nd;
  1403.  
  1404. nd = list->lh_TailPred;
  1405. while (nd != (struct Node *)list &&
  1406.         stricmp(nd->ln_Name,node->ln_Name) > 0) nd = nd->ln_Pred;
  1407.  
  1408. Insert(list,node,nd);
  1409. }
  1410.  
  1411.  
  1412.  
  1413. VOID FreeList(struct List *list)
  1414. {
  1415. struct Node *nd,*nextnd;
  1416.  
  1417.  
  1418. nd = list->lh_Head;
  1419. while (nextnd = nd->ln_Succ)
  1420. {
  1421.     Remove(nd);
  1422.     FreeVec(nd);
  1423.     nd = nextnd;
  1424. }
  1425. }
  1426.  
  1427.  
  1428.  
  1429. VOID cleanup(LONG code)
  1430. {
  1431. extern struct WBStartup *WBenchMsg;
  1432.  
  1433.  
  1434. shutdownCX();
  1435.  
  1436. closewindow();
  1437.  
  1438. if (XpkBase) CloseLibrary(XpkBase);
  1439. if (CxBase) CloseLibrary(CxBase);
  1440. if (IconBase) CloseLibrary(IconBase);
  1441. if (GadToolsBase) CloseLibrary(GadToolsBase);
  1442. if (IntuitionBase) CloseLibrary(IntuitionBase);
  1443. if (GfxBase) CloseLibrary(GfxBase);
  1444.  
  1445. if (WBenchMsg)
  1446. {
  1447.     Forbid();
  1448.     ReplyMsg(WBenchMsg);
  1449. }
  1450.  
  1451. _XCEXIT(code);
  1452. }
  1453.  
  1454.  
  1455.  
  1456. BOOL setupCX(VOID)
  1457. {
  1458. if (!(cxport = CreateMsgPort())) return(0);
  1459.  
  1460. cxsigflag = 1L << cxport->mp_SigBit;   /* Create signal mask for Wait */
  1461. mynb.nb_Port = cxport;
  1462.  
  1463. if (!(broker = CxBroker(&mynb,NULL)))
  1464. {
  1465.     shutdownCX();
  1466.     return(0);
  1467. }
  1468.  
  1469. /* install a hotkey for popping up window   */
  1470. AttachCxObj(broker,HotKey(hotkeybuff,cxport,POP_KEY_ID));
  1471.  
  1472. /* All went well so activate our broker */
  1473. ActivateCxObj(broker,1L);
  1474.  
  1475. return(1);
  1476. }
  1477.  
  1478.  
  1479.  
  1480. VOID shutdownCX(VOID)
  1481. {
  1482. struct Message *msg;
  1483.  
  1484.  
  1485. if (cxport)
  1486. {
  1487.     DeleteCxObjAll(broker);        /* safe, even if NULL   */
  1488.  
  1489.     /* now that messages are shut off, clear port   */
  1490.     while (msg = GetMsg(cxport)) ReplyMsg(msg);
  1491.  
  1492.     DeleteMsgPort(cxport);
  1493.  
  1494.     cxport = NULL;
  1495.     cxsigflag = 0;
  1496.     broker = NULL;
  1497. }
  1498. }
  1499.